/**
 *
 */
// 涉及的表名
const dbName = require("../config.js");

var dao = {};
var util = {};
// 初始化
dao.init = function(obj) {
	util = obj;
}
/**
 * 获取一个需要执行的任务
 * 调用示例
 * await vk.daoCenter.orderTaskDao.findOne();
 */
dao.findOne = async () => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.findByWhereJson({
		dbName: dbName.orderTask,
		whereJson: {
			status: 0,
			plan_exec_time: _.lte(new Date().getTime()), // 只有计划执行时间 <= 当前时间时，任务才执行
		},
		sortArr: [
			{ name: "plan_exec_time", type: "asc" }, // 按计划执行时间排序
		]
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 增 - 添加一条记录
 * @params {Object} data 添加的数据
 * 调用示例
await vk.daoCenter.orderTaskDao.addOrderTask({
	db: transaction,
	dataJson:{
		type: 1001, // 1001 订单付款 1002 订单退款
		title: `订单【${order_no}】付款成功`,
		order_no, // 订单号
		user_order_success: true, // 用户订单是否通过验证
		plan_exec_time,
	}
});
 */
dao.addOrderTask = async (obj={}) => {
	let { vk, _ } = util;
	let {
		db,
		dataJson
	} = obj;
	let res = {};
	// 获取计划结算时间
	if (vk.pubfn.isNull(dataJson.plan_exec_time)) {
		let mchInfo = await vk.daoCenter.mchDao.find();
		let planDay = vk.pubfn.getData(mchInfo, "fx.plan_exec_time", 0);
		let { todayStart } = vk.pubfn.getCommonTime();
		dataJson.plan_exec_time = vk.pubfn.getOffsetTime(todayStart, {
			day: planDay,
			mode: "after", // after 之后 before 之前
		});
	}
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.add({
		db,
		dbName: dbName.orderTask,
		dataJson: {
			status: 0,
			user_order_success: true,
			...dataJson
		}
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};




/**
 * 更新任务状态为 - 失败
 * 调用示例
await vk.daoCenter.orderTaskDao.updateStatusError({
	db: transaction,
	taskInfo,
	msg
});
 */
dao.updateStatusError = async (obj) => {
	let { vk, _ } = util;
	let {
		db,
		taskInfo,
		msg
	} = obj;
	let res = {
		code: -1,
		msg
	};
	let time = Date.now();
	let status = -1;
	await vk.baseDao.updateById({
		dbName: dbName.orderTask,
		db,
		id:taskInfo._id,
		dataJson: {
			status,
			status_error_msg: msg,
			last_exec_time: time,
			status_log: _.push({
				time,
				oldStatus: taskInfo.status,
				status,
				msg
			})
		}
	});
	return res;

};


/**
 * 更新任务状态为 - 成功
 * 调用示例
await vk.daoCenter.orderTaskDao.updateStatusSuccess({
	db: transaction,
	taskInfo
});
 */
dao.updateStatusSuccess = async (obj) => {
	let { vk, _ } = util;
	let {
		db,
		taskInfo,
		msg
	} = obj;
	let time = Date.now();
	let status = 2;
	let res = await vk.baseDao.updateById({
		dbName: dbName.orderTask,
		db,
		id:taskInfo._id,
		dataJson: {
			status,
			last_exec_time: time,
			status_log: _.push({
				time,
				oldStatus: taskInfo.status,
				status,
				msg
			})
		}
	});
	return res;
};


/**
 * 更新任务状态为 - 无需执行
 * 调用示例
await vk.daoCenter.orderTaskDao.updateStatusNoExecute({
	db: transaction,
	taskInfo
});
 */
dao.updateStatusNoExecute = async (obj) => {
	let { vk, _ } = util;
	let {
		db,
		taskInfo,
		msg
	} = obj;
	let time = Date.now();
	let status = 3;
	let res = await vk.baseDao.updateById({
		dbName: dbName.orderTask,
		db,
		id:taskInfo._id,
		dataJson: {
			status,
			last_exec_time: time,
			status_log: _.push({
				time,
				oldStatus: taskInfo.status,
				status,
				msg
			})
		}
	});
	return res;
};


/**
 * 查 - 根据id获取单条记录
 * @params {String} id
 * @params {Object} fieldJson 字段显示规则
 * 调用示例
 * let orderTaskInfo = await vk.daoCenter.orderTaskDao.findById(id);
 */
dao.findById = async (id, fieldJson) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.findById({
		dbName: dbName.orderTask,
		id,
		fieldJson
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};
/**
 * 查 - 根据whereJson获取单条记录
 * @params {Object} whereJson 条件
 * @params {Object} fieldJson 字段显示规则
 * 调用示例
let orderTaskInfo = await vk.daoCenter.orderTaskDao.findByWhereJson({

});
 */
dao.findByWhereJson = async (whereJson, fieldJson) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.findByWhereJson({
		dbName: dbName.orderTask,
		whereJson,
		fieldJson
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 增 - 添加一条记录
 * @params {Object} dataJson 添加的数据
 * 调用示例
await vk.daoCenter.orderTaskDao.add({

});
 */
dao.add = async (dataJson, db) => {
	let { vk, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.add({
		db,
		dbName: dbName.orderTask,
		dataJson
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 增 - 添加多条记录
 * @params {Object} dataJson 添加的数据
 * 调用示例
await vk.daoCenter.orderTaskDao.adds(dataArr);
 */
dao.adds = async (dataArr) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.adds({
		dbName: dbName.orderTask,
		dataJson: dataArr
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 删 - 删除多条记录
 * @params {Object} whereJson 条件
 * 调用示例
await vk.daoCenter.orderTaskDao.del({

});
 */
dao.del = async (whereJson) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.del({
		dbName: dbName.orderTask,
		whereJson
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 删 - 据ID删除单条数据
 * @params {String} id
 * 调用示例
await vk.daoCenter.orderTaskDao.deleteById(id);
 */
dao.deleteById = async (id) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.deleteById({
		dbName: dbName.orderTask,
		id
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 改 - 批量修改
 * @params {Object} whereJson 条件
 * @params {Object} dataJson 修改的数据
 * 调用示例
await vk.daoCenter.orderTaskDao.update({
	whereJson:{

	},
	dataJson:{

	}
});
 */
dao.update = async (obj = {}) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.update({
		...obj,
		dbName: dbName.orderTask,
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 改 - 根据ID修改数据
 * @params {String} id
 * @params {Object} dataJson 修改的数据
 * 调用示例
await vk.daoCenter.orderTaskDao.updateById(id, dataJson);
 */
dao.updateById = async (id, dataJson) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.updateById({
		dbName: dbName.orderTask,
		id,
		dataJson
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 改 - 更新并返回更新后的数据（无论条件匹配到多少条记录，只会修改第一条记录，同时返回修改后的数据）
 * @params {Object} whereJson 条件
 * @params {Object} dataJson 修改的数据
 * 调用示例
await vk.daoCenter.orderTaskDao.updateAndReturn({
	whereJson:{

	},
	dataJson:{

	}
});
 */
dao.updateAndReturn = async (obj = {}) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.updateAndReturn({
		...obj,
		dbName: dbName.orderTask
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 查 - 获取记录总条数
 * @params {Object} whereJson 条件
 * 调用示例
await vk.daoCenter.orderTaskDao.count(whereJson);
 */
dao.count = async (whereJson) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.count({
		dbName: dbName.orderTask,
		whereJson
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};


/**
 * 查 - 获取数据列表
 * 调用示例
let orderTaskList = await vk.daoCenter.orderTaskDao.select({
	pageIndex:1,
	pageSize:20,
	getMain:false,
	whereJson:{

	},
	fieldJson:{},
	sortArr:[{ "name":"_id", "type":"desc" }],
});
 */
dao.select = async (obj = {}) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.select({
		...obj,
		dbName: dbName.orderTask
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 查 - 获取数据列表
 * 调用示例
let orderTaskList = await vk.daoCenter.orderTaskDao.selects({
	pageIndex:1,
	pageSize:20,
	getMain:false,
	whereJson:{

	},
	fieldJson:{},
	sortArr:[{ "name":"_id", "type":"desc" }],
	// 副表列表
	foreignDB:[
		{
			dbName:"副表表名",
			localKey:"主表外键名",
			foreignKey:"副表外键名",
			as:"副表as字段",
			limit:1
		}
	]
});
 */
dao.selects = async (obj = {}) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.selects({
		...obj,
		dbName: dbName.orderTask
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 查 - 获取数据列表
 * 调用示例
res = await vk.daoCenter.orderTaskDao.getTableData({ data });
 */
dao.getTableData = async (obj = {}) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.getTableData({
		...obj,
		dbName: dbName.orderTask
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};


module.exports = dao;
